﻿using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
using CastleDefender.Platform;
using CastleDefender.ConfigFolder;


namespace CastleDefender.Object
{
    
    public class Monster : GameObject
    {
        #region VARIABLE

        protected int intLife;
        protected Vector2 vecTarget;
        protected int intSpeed;
        protected int intCountStep;
        protected int intMoveStep;
        protected int intPreMoveStep;
        protected bool blnIsMoving;
        protected TimeSpan tsTimeChangeFrames;
        protected TimeSpan tsTimeMoveStep;
        protected int intDirection;
        protected int intTimeChangeFrames;

        #endregion

        #region CONSTRUCTION

        public Monster(Game myGame, ref Texture2D texture, int widthframe, int heightframe,int type, int life, int speed, Vector2 position)
            : base(myGame, ref texture, widthframe, heightframe)
        {
            vecPosition = position;
            intSpeed = speed;
            intLife = life;
            intTimeChangeFrames = Config.MonsterTimeChangeFrame;
            intDirection = type == 0 ? 1 : -1; 
            SetState(0);
        }

        #endregion

        #region PUBLIC METHOD

        public override void Initialize()
        {
            base.Initialize();
        }

        public override void Update(GameTime gameTime)
        {
            //Thiết lập khung bao ngoài cho monster
            Bounds = new Rectangle((int)Position.X, (int)Position.Y, WidthFrame, HeightFrame);
            TimeChangeMoveStepMonster(gameTime);

            //Chuyển frame hình trong cùng trạng thái
            tsTimeChangeFrames += gameTime.ElapsedGameTime;
            if (tsTimeChangeFrames > TimeSpan.FromMilliseconds(intTimeChangeFrames))
            {
                tsTimeChangeFrames -= TimeSpan.FromMilliseconds(intTimeChangeFrames);
                intActiveFrame++;
                if (intActiveFrame >= frames[intState].Count)
                {
                    intActiveFrame = 0;

                    //Khi bị bắn trúng
                    if (intState == Config.StateAttacked)
                    {
                        SetPrevousState();
                        intMoveStep = intPreMoveStep;
                    }

                    //Khi chết
                    if (intState == Config.StateDead)
                    {
                        intLife = 0;
                        intMoveStep = intPreMoveStep;
                    }
                }
            }

            //Di chuyển 
            Move();

            base.Update(gameTime);
        }

        public override void Draw(GameTime gameTime)
        {
            base.Draw(gameTime);
        }

        public void Attacked(int power)
        {
            if (intLife > power)
            {
                intLife -= power;
                SetState(Config.StateAttacked);
            }
            else
            {
                SetState(Config.StateDead);
                intActiveFrame = 0;
            }
            intPreMoveStep = intMoveStep;
            intMoveStep = 0;
        }

        #endregion

        #region PROTECTED METHOD

        protected virtual void Move()
        {
            //Nếu không di chuyển chuyển sang trạng thái đứng cử động
            if (!blnIsMoving && intState != Config.StateStandby && intState!=Config.StateDead)
            {
                SetState(Config.StateStandby);
                intActiveFrame = 0;
                return;
            }
        }

        protected void CheckPosition()
        {
            //Kiểm tra quái di chuyển từ bên trái qua
            if (((vecPosition.X + intWidthFrame*2)
                > (vecTarget.X - Config.MonsterSafeDistance)) && vecPosition.X < vecTarget.X)
            {
                vecPosition = new Vector2(vecTarget.X - Config.MonsterSafeDistance - intWidthFrame*2,
                    vecPosition.Y);
                blnIsMoving = false;
                return;
            }

            //Kiểm tra quái di chuyển từ bên phải qua
            if (((vecPosition.X - intWidthFrame)
                 < (vecTarget.X + Config.MonsterSafeDistance)) && vecPosition.X > vecTarget.X)
            {
                vecPosition = new Vector2(vecTarget.X + Config.MonsterSafeDistance + intWidthFrame,
                    vecPosition.Y);
                blnIsMoving = false;
                return;
            }

            blnIsMoving = true;
        }

        //Xét thời gian hiệu ứng di chuyển của quái vật 
        protected void TimeChangeMoveStepMonster(GameTime gameTime)
        {
            //Khi quái bị vật phẩm tác động đi chậm
            if (intMoveStep == Config.MonsterMoveStepVerySlow)
            {
                tsTimeMoveStep += gameTime.ElapsedGameTime;
                if (tsTimeMoveStep >= TimeSpan.FromSeconds(Config.ItemTimeEffect))
                {
                    tsTimeMoveStep -= TimeSpan.FromSeconds(Config.ItemTimeEffect);
                    intMoveStep = Config.MonsterMoveStepNormal;
                }
            }

            //Khi quái bị mũi tên tác động đi chậm
            else if (intMoveStep == Config.MonsterMoveStepSlow)
            {
                tsTimeMoveStep += gameTime.ElapsedGameTime;
                if (tsTimeMoveStep >= TimeSpan.FromSeconds(Config.ArrowTimeFreeze))
                {
                    tsTimeMoveStep -= TimeSpan.FromSeconds(Config.ArrowTimeFreeze);
                    intMoveStep = Config.MonsterMoveStepNormal;
                }
            }

            //Khi quái bị vật phẩm tác động đi nhanh
            else if (intMoveStep == Config.MonsterMoveStepFast)
            {
                tsTimeMoveStep += gameTime.ElapsedGameTime;
                if (tsTimeMoveStep >= TimeSpan.FromSeconds(Config.ItemTimeEffect))
                {
                    tsTimeMoveStep -= TimeSpan.FromSeconds(Config.ItemTimeEffect);
                    intMoveStep = Config.MonsterMoveStepNormal;
                }
            }
        }

        protected void SetState(int state)
        {
            intOldState = intState;
            intState = state;
        }

        protected void SetPrevousState()
        {
            intState = intOldState;
        }

        #endregion

        #region PUBLIC PROPERTIES

        //Nhận trả giá trị Life
        public int Life
        {
            get { return intLife; }
            set { intLife = value; }
        }

        //Nhận trả giá trị intCountStep
        public int MoveStep
        {
            get { return intMoveStep; }
            set { intMoveStep = value; }
        }

        //Trả giá trị blnIsMoving
        public bool IsMoving
        {
            get { return blnIsMoving; }
        }

        //Nhận trả giá trị intTimeChangeFrames
        public int TimeChangeFrames
        {
            get { return intTimeChangeFrames; }
            set 
            {
                if (value > 0)
                {
                    intTimeChangeFrames = value;
                }
            }
        }
        #endregion

        
    }
}
